{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mpbast0s/2025-2---PPGEE---INTRODU-O-AO-APRENDIZADO-DE-M-QUINA-/blob/main/codigo_aula5_metodo_do_gradiente.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "aa948848",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "aa948848"
      },
      "source": [
        "# Método do Gradiente para Regressão Linear"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "766799f3",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "766799f3"
      },
      "source": [
        "## Objetivo\n",
        "Com este código, você irá:\n",
        "- automatizar o processo de otimizar $w$ e $b$ usando o Método do Gradiente."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1053334d",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "1053334d"
      },
      "source": [
        "## Ferramentas\n",
        "\n",
        "Nesse código, você usará:\n",
        "- NumPy, uma biblioteca popular para cálculos matriciais, etc\n",
        "- Matplotlib, uma biblioteca popular para gerar figuras a partir de dados"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "id": "4de66c47",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "4de66c47"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import math"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a62b3e2a",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "a62b3e2a"
      },
      "source": [
        "\n",
        "## Definição do Problema\n",
        "\n",
        "\n",
        "Usaremos as mesmas amostras de dados que já utilizamos em códigos anteriores:\n",
        "\n",
        "| Corrente (A) | Tensão (V) calculada |\n",
        "| ------------ | -------------------- |\n",
        "| 0.2          | 10.64975337          |\n",
        "| 2.0          | 106.49753367         |\n",
        "| 5.0          | 266.24383418         |\n",
        "| 10.0         | 532.48766835         |\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "id": "5a3b802b",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "5a3b802b"
      },
      "outputs": [],
      "source": [
        "# Carregando nosso conjunto de dados:\n",
        "x_trein = np.array([ 0.2,2.,5.,10.])       # característica\n",
        "y_trein = np.array([ 10.64975337,106.49753367,266.24383418,532.48766835])    # valor alvo"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "17b7456f",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "17b7456f"
      },
      "source": [
        "## Calculando o Custo\n",
        "\n",
        "Essa parte foi desenvolvida no nosso último código. Vamos precisar aqui novamente:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "id": "f2a48aea",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "f2a48aea"
      },
      "outputs": [],
      "source": [
        "def calcula_custo(x, y, w, b):\n",
        "    \"\"\"\n",
        "    Calcula a função custo no âmbito da regressão linear.\n",
        "    Argumentos da função:\n",
        "      x (ndarray (m,)): Conjunto de dados com m amostras\n",
        "      y (ndarray (m,)): Valores alvo de saída\n",
        "      w,b (escalar)   : Parâmetros do modelo\n",
        "    Retorna\n",
        "      custo_total (float): O custo custo de se usar w,b como parâmetros na regressão linear\n",
        "               para ajustar os dados\n",
        "    \"\"\"\n",
        "    # número de amostras de treinamento\n",
        "    m = x.shape[0]\n",
        "\n",
        "    soma_custo = 0\n",
        "    for i in range(m):\n",
        "        f_wb = w * x[i] + b\n",
        "        custo = (f_wb - y[i]) ** 2\n",
        "        soma_custo = soma_custo + custo\n",
        "    custo_total = (1 / (2 * m)) * soma_custo\n",
        "\n",
        "    return custo_total"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "573b53d2",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "573b53d2"
      },
      "source": [
        "\n",
        "## Método do Gradiente\n",
        "Por enquanto, você já desenvolveu um modelo linear que estima $f_{w,b}(x^{(i)})$:\n",
        "\n",
        "$$f_{w,b}(x^{(i)}) = wx^{(i)} + b \\tag{1}$$\n",
        "\n",
        "Na regressão linear, você utiliza dados de treinamento para ajustar os parâmetros $w$,$b$ minimizando o erro entre suas previsões $f_{w,b}(x^{(i)})$ e os dados verdadeiros $y^{(i)}$. A soma dos erros quadráticos para todas as amostras $(x^{(i)},y^{(i)})$ é chamada de custo, e é denotada por $J(w,b)$:\n",
        "$$J(w,b) = \\frac{1}{2m} \\sum\\limits_{i = 0}^{m-1} (f_{w,b}(x^{(i)}) - y^{(i)})^2\\tag{2}$$"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ae986d82",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "ae986d82"
      },
      "source": [
        "\n",
        "O Método do Gradiente então consiste em:\n",
        "\n",
        "$$\\begin{align*} \\text{repetir}&\\text{ até convergir:} \\; \\lbrace \\newline\n",
        "\\;  w &= w -  \\alpha \\frac{\\partial J(w,b)}{\\partial w} \\tag{3}  \\; \\newline\n",
        " b &= b -  \\alpha \\frac{\\partial J(w,b)}{\\partial b}  \\newline \\rbrace\n",
        "\\end{align*}$$\n",
        "onde os parâmetros $w$, $b$ devem ser atualizados simultaneamente.  \n",
        "\n",
        "O gradiente é definido como:\n",
        "$$\n",
        "\\begin{align}\n",
        "\\frac{\\partial J(w,b)}{\\partial w}  &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{w,b}(x^{(i)}) - y^{(i)})x^{(i)} \\tag{4}\\\\\n",
        "  \\frac{\\partial J(w,b)}{\\partial b}  &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{w,b}(x^{(i)}) - y^{(i)}) \\tag{5}\\\\\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "Aqui, 'simultaneamente' significa que você deve calcular as derivadas parciais para todos os parâmetros antes de atualizar qualquer um desses parâmetros."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6ed14caf",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "6ed14caf"
      },
      "source": [
        "\n",
        "## Implementando o Método do Gradiente na Prática.\n",
        "Você irá implementar o método do gradiente para uma única variável (característica). Para fazer isso, você precisará de três funções:\n",
        "- `calcula_gradiente` implementando as equações (4) e (5) acima descritas\n",
        "- `calcula_custo` implementando a equação (2) acima\n",
        "- `metodo_do_gradiente`, utilizando as funções calcula_gradiente e calcula_custo\n",
        "\n",
        "Convenções:\n",
        "- A terminologia que usaremos em Python para variáveis contendo derivadas parciais é a serguinte: $\\frac{\\partial J(w,b)}{\\partial b}$  será `dj_db`.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "416b457c",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "416b457c"
      },
      "source": [
        "\n",
        "### calcula_gradiente\n",
        "\n",
        "\n",
        "`calcula_gradiente`  implementa (4) e (5) acima e retorna $\\frac{\\partial J(w,b)}{\\partial w}$,$\\frac{\\partial J(w,b)}{\\partial b}$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "id": "29125631",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "29125631"
      },
      "outputs": [],
      "source": [
        "def calcula_gradiente(x, y, w, b):\n",
        "    \"\"\"\n",
        "    Calcula o gradiente para Regressão Linear\n",
        "    Argumentos da função:\n",
        "      x (ndarray (m,)): Conjunto de dados com m amostras\n",
        "      y (ndarray (m,)): Valores alvo de saída\n",
        "      w,b (scalar)    : parâmetros do modelo\n",
        "    Retorna\n",
        "      dj_dw (scalar): O gradiente do custo em relação ao parâmetros w\n",
        "      dj_db (scalar): O gradiente do custo em relação ao parâmetros b\n",
        "     \"\"\"\n",
        "\n",
        "    # Número de amostras de treinamento\n",
        "    m = x.shape[0]\n",
        "    dj_dw = 0\n",
        "    dj_db = 0\n",
        "\n",
        "    for i in range(m):\n",
        "        f_wb = w * x[i] + b\n",
        "        dj_dw_i = (f_wb - y[i]) * x[i]\n",
        "        dj_db_i = f_wb - y[i]\n",
        "\n",
        "        dj_db += dj_db_i\n",
        "        dj_dw += dj_dw_i\n",
        "\n",
        "    dj_dw = dj_dw / m\n",
        "    dj_db = dj_db / m\n",
        "\n",
        "    return dj_dw, dj_db"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c6a1a1db",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "c6a1a1db"
      },
      "source": [
        "<br/>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "03c73a11",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "03c73a11"
      },
      "source": [
        "### Testando nossa implementação da função calcula_gradiente\n",
        "\n",
        "\n",
        "Utilizando as linhas de código abaixo, teste diferentes valores para $b$ e $w$ com o objetivo de encontrar o valor mínimo da função custo $J(w,b)$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "id": "037d486c",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "037d486c",
        "outputId": "fa3dcab8-f593-408c-d8c3-cb2cb3495888"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.039781896499886574\n",
            "0.005302607499986678\n"
          ]
        }
      ],
      "source": [
        "b = 0\n",
        "w = 53.25\n",
        "\n",
        "dj_dw, dj_db = calcula_gradiente(x_trein, y_trein, w, b)\n",
        "\n",
        "print(dj_dw)\n",
        "print(dj_db)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "56af70db",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "56af70db"
      },
      "source": [
        "### Método do Gradiente\n",
        "\n",
        "Agora que o gradiente pode ser calculado, o Método do Gradiente, descrito na equação (3), é implementado abaixo por meio da função `metodo_do_gradiente`. Os detalhes da implementação estão descritos nos comentários. Abaixo, você vai utilizar essa função para encontrar os valores ótimos para $w$ e $b$ levando em conta o conjunto de dados de treinamento."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "id": "3ebef798",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "3ebef798"
      },
      "outputs": [],
      "source": [
        "def metodo_do_gradiente(x, y, w_in, b_in, alpha, num_iters, calcula_custo, calcula_gradiente):\n",
        "    \"\"\"\n",
        "    Aplica o Método do Gradiente para ajustar w,b. Atualiza w,b ao longo de\n",
        "    num_iters passos (iterações) assumindo uma taxa de aprendizado alpha\n",
        "\n",
        "    Argumentos da função:\n",
        "      x (ndarray (m,))  : Conjunto de dados com m amostras\n",
        "      y (ndarray (m,))  : Valores alvo de saída\n",
        "      w_in,b_in (scalar): valores iniciais para os parâmetros w,b\n",
        "      alpha (float):      taxa de aprendizado\n",
        "      num_iters (int):    número de iterações para o método\n",
        "      calcula_custo:      função responsável por calcular o custo\n",
        "      calcula_gradiente:  função responsável por calcular o gradiente\n",
        "\n",
        "    Retorna:\n",
        "      w (scalar): Valor atualizado para w após rodar o Método do Gradiente\n",
        "      b (scalar): Valor atualizado para b após rodar o Método do Gradiente\n",
        "      J_history (List): Contém o histórico dos valores de custo\n",
        "      p_history (list): Contém o histórico dos valores para [w,b]\n",
        "      \"\"\"\n",
        "\n",
        "    # Arrays que armazenam os valores históricos de J e w para cada iteração para que seja possível fazer gráfico depois\n",
        "    J_history = []\n",
        "    p_history = []\n",
        "    b = b_in\n",
        "    w = w_in\n",
        "\n",
        "    for i in range(num_iters):\n",
        "        # Calcula o gradiente usando a função calcula_gradiente\n",
        "        dj_dw, dj_db = calcula_gradiente(x, y, w , b)\n",
        "\n",
        "        # Atualiza os parâmetros w,b a partir do gradiente calculado\n",
        "        b = b - alpha * dj_db\n",
        "        w = w - alpha * dj_dw\n",
        "\n",
        "        # Salva o custo J para cada iteração\n",
        "        if i<100000:\n",
        "            J_history.append( calcula_custo(x, y, w , b))\n",
        "            p_history.append([w,b])\n",
        "        # Faz print em tempo real enquanto o Método do Gradiente estiver rodando\n",
        "        if i% math.ceil(num_iters/10) == 0:\n",
        "            print(f\"Iteração {i:4}: Custo {J_history[-1]:0.2e} \",\n",
        "                  f\"dj_dw: {dj_dw: 0.3e}, dj_db: {dj_db: 0.3e}  \",\n",
        "                  f\"w: {w: 0.3e}, b:{b: 0.5e}\")\n",
        "\n",
        "    return w, b, J_history, p_history #retorna w,b e valores históricos"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "id": "0d56b234",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0d56b234",
        "outputId": "ede082f9-b162-4ea4-d86a-2907ab85bc0a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iteração    0: Custo 2.06e+04  dj_dw: -1.718e+03, dj_db: -2.290e+02   w:  1.718e+01, b: 2.28970e+00\n",
            "Iteração  300: Custo 8.49e-01  dj_dw: -1.134e-01, dj_db:  8.395e-01   w:  5.298e+01, b: 1.99378e+00\n",
            "Iteração  600: Custo 6.82e-02  dj_dw: -3.214e-02, dj_db:  2.380e-01   w:  5.317e+01, b: 5.65242e-01\n",
            "Iteração  900: Custo 5.48e-03  dj_dw: -9.112e-03, dj_db:  6.747e-02   w:  5.323e+01, b: 1.60248e-01\n",
            "Iteração 1200: Custo 4.41e-04  dj_dw: -2.583e-03, dj_db:  1.913e-02   w:  5.324e+01, b: 4.54306e-02\n",
            "Iteração 1500: Custo 3.54e-05  dj_dw: -7.324e-04, dj_db:  5.423e-03   w:  5.325e+01, b: 1.28797e-02\n",
            "Iteração 1800: Custo 2.85e-06  dj_dw: -2.076e-04, dj_db:  1.537e-03   w:  5.325e+01, b: 3.65142e-03\n",
            "Iteração 2100: Custo 2.29e-07  dj_dw: -5.886e-05, dj_db:  4.359e-04   w:  5.325e+01, b: 1.03519e-03\n",
            "Iteração 2400: Custo 1.84e-08  dj_dw: -1.669e-05, dj_db:  1.236e-04   w:  5.325e+01, b: 2.93480e-04\n",
            "Iteração 2700: Custo 1.48e-09  dj_dw: -4.731e-06, dj_db:  3.503e-05   w:  5.325e+01, b: 8.32043e-05\n",
            "(w,b) Encontrados pelo Método do Gradiente: ( 53.2488,  0.0000)\n"
          ]
        }
      ],
      "source": [
        "# Inicialização de parâmetros\n",
        "w_init = 0\n",
        "b_init = 0\n",
        "# Parametrização do Método do Gradiente:\n",
        "iteracoes = 3000\n",
        "alpha = 1.0e-2\n",
        "# Roda o método do gradiente\n",
        "w_final, b_final, J_hist, p_hist = metodo_do_gradiente(x_trein ,y_trein, w_init, b_init, alpha,\n",
        "                                                    iteracoes, calcula_custo, calcula_gradiente)\n",
        "print(f\"(w,b) Encontrados pelo Método do Gradiente: ({w_final:8.4f},{b_final:8.4f})\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e1f7866a",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "e1f7866a"
      },
      "source": [
        "Observe algumas características do Método do Gradiente:\n",
        "\n",
        "- O Custo começa elevado e decai rapidamente, conforme vimos na teoria.\n",
        "- As derivadas parciais, `dj_dw`, e `dj_db` também diminuem, inicialmente mais rapidamente e depois mais devagar. Isso acontece porque as derivadas parciais se aproximam de zero à medida com que nos aproximamos do mínimo da função"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f5b77602",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "f5b77602"
      },
      "source": [
        "### Custo versus iterações no Método do Gradiente\n",
        "\n",
        "Um gráfico do custo versus iterações é uma métrica interessante para verificarmos o progresso feito pelo método. O custo deve sempre decair ao longo das iterações. A mudança no custo é rápida inicialmente, portanto, é útil plotar as primeiras iterações numa escala diferente das últimas iterações. Observe as escalas usadas nos gráficos abaixo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "id": "5e8148a8",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "5e8148a8",
        "outputId": "aa9f53a6-67ba-4e34-b64a-42d77dd4455d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x400 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# gráficos do custo versus iterações\n",
        "fig, (ax1, ax2) = plt.subplots(1, 2, constrained_layout=True, figsize=(12,4))\n",
        "ax1.plot(J_hist[:100])\n",
        "ax2.plot(500 + np.arange(len(J_hist[500:])), J_hist[500:])\n",
        "ax1.set_title(\"Custo vs. iteração(primeiras iterações)\");  ax2.set_title(\"Custo vs. iteração(últimas iterações)\")\n",
        "ax1.set_ylabel('Custo')            ;  ax2.set_ylabel('Custo')\n",
        "ax1.set_xlabel('iteração')  ;  ax2.set_xlabel('iteração')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5c5c974e",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "5c5c974e"
      },
      "source": [
        "### Previsões\n",
        "\n",
        "\n",
        "Agora que você já descobriu os valores ótimos para os parâmetros $w$ e $b$, você pode usar o modelo para prever o valor de tensão do resistor para diferentes valores de corrente.\n",
        "\n",
        "Olhe os exemplos abaixo:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "id": "006b13f0",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "006b13f0",
        "outputId": "154d80d5-6681-412e-8846-f893907877db"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Para uma corrente de 1 A temos uma tensão esperada de 53.2 Volts\n",
            "Para uma corrente de 2.35 A temos uma tensão esperada de 125.1 Volts\n",
            "Para uma corrente de 3 A temos uma tensão esperada de 159.7 Volts\n"
          ]
        }
      ],
      "source": [
        "print(f\"Para uma corrente de 1 A temos uma tensão esperada de {w_final*1.0 + b_final:0.1f} Volts\")\n",
        "print(f\"Para uma corrente de 2.35 A temos uma tensão esperada de {w_final*2.35 + b_final:0.1f} Volts\")\n",
        "print(f\"Para uma corrente de 3 A temos uma tensão esperada de {w_final*3.0 + b_final:0.1f} Volts\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7dc45f74",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "7dc45f74"
      },
      "source": [
        "\n",
        "## Parabéns!\n",
        "Você aprendeu o seguinte com esse código:\n",
        "- Detalhes importantes acerca do Método do Gradiente para uma variável\n",
        "- Desenvolveu uma rotina para o cálculo do gradiente\n",
        "- completou a rotina que aplica o Método do Gradiente\n",
        "- Utilizou o Método do Gradiente para encontrar os parâmetros ótimos para um modelo na forma de reta"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "id": "924a27ce",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "924a27ce"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "dl_toc_settings": {
      "rndtag": "40291"
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.12"
    },
    "toc-autonumbering": false,
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}